home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1994 August: Tool Chest / Dev.CD Aug 94.toast / Tool Chest / Developer Utilities / Installer 4.0GM SDK / Script Examples / Simple Atom Extender / DirectCopyExtender.c next >
Encoding:
C/C++ Source or Header  |  1994-02-10  |  17.3 KB  |  479 lines  |  [TEXT/MPS ]
  1.  
  2. #ifndef __Errors__
  3. #include <Errors.h>
  4. #endif
  5.  
  6. #ifndef __Memory__
  7. #include <Memory.h>
  8. #endif
  9.  
  10. #ifndef __OSUtils__
  11. #include <OSUtils.h>
  12. #endif
  13.  
  14. #ifndef __Packages__
  15. #include <Packages.h>
  16. #endif
  17.  
  18. #ifndef __AtomExtenderHeader__
  19. #include "AtomExtenderHeader.h"
  20. #endif
  21.  
  22. #ifndef __ActionHandlerHeader__
  23. #include "ActionHandlerHeader.h"
  24. #endif
  25.  
  26. void DisplayAtomExtenderInfo( ExtenderPBPtr        pExtenderPBPtr, ExtenderResultCode pResultCode );
  27.  
  28. ExtenderResultCode DirectCopyExtender( ExtenderPBPtr        pExtenderPBPtr )
  29. {
  30.     OSErr                theErr;
  31.     long                dataLen;
  32.     Ptr                    theBufferPtr;
  33.     ExtenderResultCode    resultCode;
  34.  
  35.     // -- Initalize some important variables
  36.     dataLen = 30000;
  37.     theErr = noErr;
  38.  
  39.     // -- Depending on the message, perform the proper task
  40.     switch( pExtenderPBPtr->fFileCopyPBRec.fEnvironmentHeader.fMessageID ) {
  41.  
  42.         case kBeforePart:
  43.         
  44.             // -- Create a buffer
  45.             theBufferPtr = NewPtr(dataLen);
  46.         
  47.             // -- Check that we got our buffer successfully
  48.             if( theBufferPtr != NULL && MemError() == noErr ) {
  49.         
  50.                 // -- Read as much as we can up to the size of the buffer.
  51.                 theErr = ReadSourceData( pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fCallBackProcPtr, &dataLen, theBufferPtr);
  52.  
  53.                 // -- Loop while there is more data to read. 
  54.                 while( dataLen > 0 ) {
  55.         
  56.         
  57.                     // -- DO SOMETHING TO THE DATA HERE, LIKE DECOMPRESSION IF YOU NEED TO
  58.         
  59.         
  60.                     // -- Write the data out.
  61.                     theErr = WriteTargetData( pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fCallBackProcPtr, dataLen, theBufferPtr);
  62.                     
  63.                     // -- Read as much as we can up to the size of the buffer.
  64.                     if( theErr == noErr ) {
  65.                         theErr = ReadSourceData( pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fCallBackProcPtr, &dataLen, theBufferPtr);
  66.                         
  67.                         // -- If we got an eofErr, then we know we're done, and dataLen will be 0 (zero).
  68.                         if( theErr == eofErr )
  69.                             theErr = noErr;
  70.                     }
  71.  
  72.                 } // while not done copying
  73.  
  74.                 if( theErr == noErr )
  75.                     resultCode = kCopiedData;
  76.                 else
  77.                     resultCode = kFatalError;
  78.  
  79.                 // -- Dispose the buffer
  80.                 DisposPtr(theBufferPtr);
  81.             }
  82.             else
  83.                 resultCode = kFatalError;
  84.  
  85.             // Write some handy info to the Installer Debugger, if it is installed.
  86.             DisplayAtomExtenderInfo( pExtenderPBPtr, resultCode );
  87.             break;
  88.     
  89.         // -- We ignore the other messages.
  90.         case kInitialize:
  91.         case kAfterPart:    
  92.         case kSuccess:    
  93.         case kCancel:
  94.             resultCode = kContinueAsNormal;
  95.             break;
  96.     }
  97.     
  98.     return resultCode;
  99. }
  100.  
  101.  
  102.  
  103.  
  104.  
  105.  
  106. // -------------------------------------------------------------------------------------------------------------------------------------
  107. // The routines below are for displaying the contents of the parameter block passed to the Atom Extender.
  108. // Call DisplayAtomExtenderInfo to write this information to the Installer Debugger.
  109.  
  110. void MakeFilePath( FSSpec* pFileFSSpec, Str255  pFilePath )
  111. {
  112.     
  113.     CInfoPBRec        cPBRec;
  114.     Str255            directoryName = "";
  115.     short            i;
  116.     OSErr            theErr;
  117.  
  118.     // Get the file name
  119.     for( i=0;i<=pFileFSSpec->name[0];i++)
  120.         pFilePath[i] = pFileFSSpec->name[i];
  121.  
  122.     cPBRec.hFileInfo.ioCompletion = NULL;
  123.     cPBRec.hFileInfo.ioNamePtr = directoryName;
  124.     cPBRec.hFileInfo.ioFDirIndex = -1;
  125.     cPBRec.hFileInfo.ioDirID = pFileFSSpec->parID;
  126.     cPBRec.hFileInfo.ioVRefNum = pFileFSSpec->vRefNum;
  127.     theErr = PBGetCatInfo( &cPBRec, 0 );
  128.  
  129.     // Preappend directoryName
  130.     BlockMove( pFilePath + 1, pFilePath + directoryName[0] + 2, pFilePath[0] );
  131.     for( i=1;i<=directoryName[0];i++)
  132.         pFilePath[i] = directoryName[i];
  133.     pFilePath[i] = ':';
  134.     pFilePath[0] += directoryName[0] + 1;
  135.  
  136.     while ( theErr == noErr && cPBRec.dirInfo.ioDrParID != 1 && pFilePath[0] + directoryName[0] + 1 < 255 ) {
  137.  
  138.     // Preappend directoryName
  139.         cPBRec.hFileInfo.ioDirID = cPBRec.dirInfo.ioDrParID;
  140.         cPBRec.hFileInfo.ioFDirIndex = -1;
  141.         theErr = PBGetCatInfo( &cPBRec, 0 );
  142.  
  143.         if( theErr == noErr ) {
  144.             // Preappend directoryName
  145.             BlockMove( pFilePath + 1, pFilePath + directoryName[0] + 2, pFilePath[0] );
  146.             for( i=1;i<=directoryName[0];i++)
  147.                 pFilePath[i] = directoryName[i];
  148.             pFilePath[i] = ':';
  149.             pFilePath[0] += directoryName[0] + 1;
  150.         }
  151.     }
  152.  
  153. }
  154.  
  155. void PrintLine( ProcPtr pCallBackProcPtr, Str255 pParam0, Str255 pParam1, Str255 pParam2, Str255 pParam3 )
  156. {
  157.     long    theResult;
  158.     RegisterScriptAction( pCallBackProcPtr, kDebuggingAction, kGenericDebugActID, pParam0, pParam1, pParam2, pParam3, &theResult );    
  159. }
  160.  
  161. void DisplayAtomExtenderInfo( ExtenderPBPtr        pExtenderPBPtr, ExtenderResultCode pResultCode )
  162. {
  163.  
  164. StringPtr                    kBeginCallPart1                    = "\p=>========================== Begin Atom Extender Call ==== ";
  165. StringPtr                    kBeginCallPart3                    = "\p============================";
  166.  
  167. StringPtr                    kEndCallPart1                    = "\p-<-------------------------- End Atom Extender Call ------ ";
  168. StringPtr                    kEndCallPart3                    = "\p----------------------------\n";
  169.  
  170. StringPtr                    kRefConText                        = "\pRefCon: ";
  171.  
  172. StringPtr                    kTargetVolNumText                = "\p    TargetVolumeRefNum:  ";
  173. StringPtr                    kTargetBlessedDirIDText            = "\p    TargetBlessedDirID:  ";
  174. StringPtr                    kBootVolNumText                    = "\p      BootVolumeRefNum:  ";
  175. StringPtr                    kBootBlessedDirIDText            = "\p      BootBlessedDirID:  ";
  176.  
  177. StringPtr                    kInitializeText                    = "\pInitialization Call =";
  178. StringPtr                    kSuccessText                    = "\pSuccessful Completion";
  179. StringPtr                    kBeforePartText                    = "\pBefore Part =========";
  180. StringPtr                    kAfterPartText                    = "\pAfter Part ==========";
  181. StringPtr                    kCancelText                        = "\pCANCELIZATION CALL ==";
  182.  
  183. StringPtr                    kOkRtnMessageText                ="\pContinue result returned --";
  184. StringPtr                    kCancelRtnMessageText            ="\pCancel result returned ----";
  185. StringPtr                    kErrorRtnMessageText            ="\pError result returned -----";
  186. StringPtr                    kCopiedDataMessageText            ="\pCopied Data result returned";
  187.  
  188. StringPtr                    kFileAtomDataForkText            = "\pDataType:  FileAtomDataFork";
  189. StringPtr                    kFileAtomRsrcForkText            = "\pDataType:  FileAtomRsrcFork";
  190. StringPtr                    kFileAtomRsrcForkFromDataForkText= "\pDataType:  FileAtomRsrcForkFromDataFork";
  191. StringPtr                    kRsrcAtomText                    = "\pDataType:  RsrcAtom";
  192. StringPtr                    kFontAtomText                    = "\pDataType:  FontAtom";
  193. StringPtr                    kActionAtomText                    = "\pDataType:  N/A";
  194.  
  195. StringPtr                    kSourceFileText                    = "\pSource Info...  ";
  196. StringPtr                    kTargetFileText                    = "\pTarget Info...  ";
  197. StringPtr                    kFSSpecNameText                    = "\p      File Path:  ";
  198. StringPtr                    kPartSizeText                    = "\p      Part Size:  ";
  199. StringPtr                    kPosSizeText                    = "\p      Start Pos:  ";
  200. StringPtr                    kTotalSizeText                    = "\p     Total Size:  ";
  201.  
  202. StringPtr                    kRsrcSourceRsrcTypeText            = "\p  Src Rsrc Type:  ";
  203. StringPtr                    kRsrcSourceRsrcIDText            = "\p    Src Rsrc ID:  ";
  204. StringPtr                    kRsrcTargetRsrcTypeText            = "\p  Tgt Rsrc Type:  ";
  205. StringPtr                    kRsrcTargetRsrcIDText            = "\p    Tgt Rsrc ID:  ";
  206. StringPtr                    kRsrcTargetRsrcNameText            = "\p      Rsrc Name:  ";
  207. StringPtr                    kRsrcTargetRsrcAttrsText        = "\p     Rsrc Attrs:  ";
  208.  
  209. StringPtr                    kFontSourceRsrcTypeText            = "\p  Src Rsrc Type:  ";
  210. StringPtr                    kFontSourceRsrcIDText            = "\p    Src Rsrc ID:  ";
  211. StringPtr                    kFontTargetRsrcTypeText            = "\p  Tgt Rsrc Type:  ";
  212. StringPtr                    kFontTargetRsrcIDText            = "\p    Tgt Rsrc ID:  ";
  213. StringPtr                    kFontTargetRsrcNameText            = "\p      Rsrc Name:  ";
  214. StringPtr                    kFontTargetRsrcAttrsText        = "\p     Rsrc Attrs:  ";
  215. StringPtr                    kFontFamilyNameText                = "\p    Family Name:  ";
  216. StringPtr                    kFontFamilyIDText                = "\p      Family ID:  ";
  217. StringPtr                    kFontFontSizeText                = "\p      Font Size:  ";
  218. StringPtr                    kFontFontStyleText                = "\p     Font Style:  ";
  219.  
  220. StringPtr                    kInstallerTempDirIDText            = "\p Temp Directory:  ";
  221.  
  222. Str255                        tempNumStr;    
  223. Str255                        tempStr255;
  224. FSSpec                        tempFSSpec;
  225. ProcPtr                        theCallBackPtr = pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fCallBackProcPtr;
  226.  
  227.  
  228. // -- BASIC STUFF ----------------------------------------------------------------------
  229.  
  230.     switch (pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fMessageID) {
  231.         case kInitialize :        PrintLine( theCallBackPtr, kBeginCallPart1, kInitializeText, kBeginCallPart3, "\p" );
  232.                                 break;
  233.         case kSuccess :            PrintLine( theCallBackPtr, kBeginCallPart1, kSuccessText, kBeginCallPart3, "\p" );
  234.                                 break;
  235.         case kBeforePart :        PrintLine( theCallBackPtr, kBeginCallPart1, kBeforePartText, kBeginCallPart3, "\p" );
  236.                                 break;
  237.         case kAfterPart :        PrintLine( theCallBackPtr, kBeginCallPart1, kAfterPartText, kBeginCallPart3, "\p" );
  238.                                 break;
  239.         case kCancel :            PrintLine( theCallBackPtr, kBeginCallPart1, kCancelText, kBeginCallPart3, "\p" );
  240.                                 break;
  241.         }
  242.     
  243.     switch (pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fMessageID) {
  244.         case kInitialize :
  245.         case kSuccess :
  246.         case kCancel :
  247.             NumToString( pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fRefCon, &tempNumStr );
  248.             PrintLine( theCallBackPtr, kRefConText, tempNumStr, "\p", "\p" );
  249.             break;
  250.             
  251.         case kBeforePart :
  252.         case kAfterPart :
  253.             
  254.             NumToString( pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fRefCon, &tempNumStr );
  255.             PrintLine( theCallBackPtr, kRefConText, tempNumStr, "\p", "\p" );
  256.                                 
  257.             switch (pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fDataType) {
  258.                 case kFileAtomDataFork :                PrintLine( theCallBackPtr, kFileAtomDataForkText, "\p", "\p", "\p" );
  259.                                                         break;
  260.                 case kFileAtomRsrcFork :                PrintLine( theCallBackPtr, kFileAtomRsrcForkText, "\p", "\p", "\p" );
  261.                                                         break;
  262.                 case kFileAtomRsrcForkFromDataFork :    PrintLine( theCallBackPtr, kFileAtomRsrcForkFromDataForkText, "\p", "\p", "\p" );
  263.                                                         break;
  264.                 case kRsrcAtom :                        PrintLine( theCallBackPtr, kRsrcAtomText, "\p", "\p", "\p" );
  265.                                                         break;
  266.                 case kFontAtom :                        
  267.                                                         // -- Font Atom Description
  268.                                                         PrintLine( theCallBackPtr, kFontAtomText, "\p", "\p", "\p" );
  269.                                                     
  270.                                                         // -- Font Family Name
  271.                                                         PrintLine( theCallBackPtr, kFontFamilyNameText, pExtenderPBPtr->fFontCopyPBRec.fFamilyName, "\p", "\p" );
  272.                                     
  273.                                                         // -- Font Family ID
  274.                                                         NumToString( pExtenderPBPtr->fFontCopyPBRec.fFamilyID, &tempNumStr );
  275.                                                         PrintLine( theCallBackPtr, kFontFamilyIDText, tempNumStr, "\p", "\p" );
  276.                                                         
  277.                                                         // -- Font Strike Size
  278.                                                         NumToString( pExtenderPBPtr->fFontCopyPBRec.fFontSize, &tempNumStr );
  279.                                                         PrintLine( theCallBackPtr, kFontFontSizeText, tempNumStr, "\p", "\p" );
  280.                                                         
  281.                                                         // -- Font Strike Style
  282.                                                         NumToString( pExtenderPBPtr->fFontCopyPBRec.fFontStyle, &tempNumStr );
  283.                                                         PrintLine( theCallBackPtr, kFontFontStyleText, tempNumStr, "\p", "\p" );
  284.                                                         break;
  285.                     
  286.                 case kActionAtom :                        PrintLine( theCallBackPtr, kActionAtomText, "\p", "\p", "\p" );
  287.                                                         break;
  288.                 }
  289.                                 break;
  290.         }
  291.  
  292.  
  293. // -- BASIC SOURCE INFO ----------------------------------------------------------------------
  294.  
  295.     switch (pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fMessageID) {
  296.          case kBeforePart :
  297.         case kAfterPart :
  298.         // -- SOURCE FILE ----------------------------------------------------------------------
  299.             // -- Source Title
  300.             PrintLine( theCallBackPtr, kSourceFileText, "\p", "\p", "\p" );
  301.         
  302.             MakeFilePath( &(pExtenderPBPtr->fBasicPBRec.fCopyPBHeader.fSourceFile), tempStr255 );
  303.             PrintLine( theCallBackPtr, kFSSpecNameText, tempStr255, "\p", "\p" );
  304.         
  305.             NumToString( pExtenderPBPtr->fBasicPBRec.fCopyPBHeader.fSourcePartSize, &tempNumStr );
  306.             PrintLine( theCallBackPtr, kPartSizeText, tempNumStr, "\p", "\p" );
  307.             break;
  308.         }
  309.     
  310. // -- ATOM SOURCE SPECIFIC INFO ----------------------------------------------------------------------
  311.  
  312.     switch (pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fMessageID) {
  313.         case kInitialize :
  314.         case kSuccess :
  315.             break;
  316.         case kBeforePart :
  317.         case kAfterPart :
  318.             switch (pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fDataType) {
  319.                 case kFileAtomDataFork :
  320.                 case kFileAtomRsrcFork :
  321.                 case kFileAtomRsrcForkFromDataFork :
  322.                     break;
  323.                 case kRsrcAtom :
  324.                     // -- Resource Source Type
  325.                     BlockMove( &(pExtenderPBPtr->fRsrcCopyPBRec.fSourceRsrcType), &(tempStr255[2]), 4 );
  326.                     tempStr255[1] = '\'';
  327.                     tempStr255[6] = '\'';
  328.                     tempStr255[0] = 6;
  329.                     PrintLine( theCallBackPtr, kRsrcSourceRsrcTypeText, tempStr255, "\p", "\p" );
  330.                     
  331.                     // -- Resource Source ID
  332.                     NumToString( pExtenderPBPtr->fRsrcCopyPBRec.fSourceRsrcID, &tempNumStr );
  333.                     PrintLine( theCallBackPtr, kRsrcSourceRsrcIDText, tempNumStr, "\p", "\p" );
  334.  
  335.                     break;
  336.                 case kFontAtom :
  337.                     // -- Font Source Type
  338.                     BlockMove( &(pExtenderPBPtr->fFontCopyPBRec.fSourceFontRsrcType), &(tempStr255[2]), 4 );
  339.                     tempStr255[1] = '\'';
  340.                     tempStr255[6] = '\'';
  341.                     tempStr255[0] = 6;
  342.                     PrintLine( theCallBackPtr, kFontSourceRsrcTypeText, tempStr255, "\p", "\p" );
  343.                 
  344.                     // -- Font Source ID
  345.                     NumToString( pExtenderPBPtr->fFontCopyPBRec.fSourceFontRsrcID, &tempNumStr );
  346.                     PrintLine( theCallBackPtr, kFontSourceRsrcIDText, tempNumStr, "\p", "\p" );
  347.  
  348.                     break;
  349.                 default :
  350.                     break;
  351.                 }
  352.             break;
  353.         case kCancel :
  354.                 break;
  355.         }
  356.  
  357.  
  358. // -- BASIC TARGET INFO ----------------------------------------------------------------------
  359.  
  360.     switch (pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fMessageID) {
  361.          case kBeforePart :
  362.         case kAfterPart :
  363.         
  364.         // -- TARGET FILE ----------------------------------------------------------------------
  365.             // -- Target Title
  366.             PrintLine( theCallBackPtr, kTargetFileText, "\p", "\p", "\p" );
  367.         
  368.             // -- Target File Name
  369.             MakeFilePath( &(pExtenderPBPtr->fBasicPBRec.fCopyPBHeader.fTargetFile), tempStr255 );
  370.             PrintLine( theCallBackPtr, kFSSpecNameText, tempStr255, "\p", "\p" );
  371.         
  372.             // -- Target Start Position
  373.             NumToString( pExtenderPBPtr->fBasicPBRec.fCopyPBHeader.fTargetPosStart, &tempNumStr );
  374.             PrintLine( theCallBackPtr, kPosSizeText, tempNumStr, "\p", "\p" );
  375.         
  376.             // -- Target Part Size
  377.             NumToString( pExtenderPBPtr->fBasicPBRec.fCopyPBHeader.fTargetPartSize, &tempNumStr );
  378.             PrintLine( theCallBackPtr, kPartSizeText, tempNumStr, "\p", "\p" );
  379.         
  380.             // -- Target Total Size
  381.             NumToString( pExtenderPBPtr->fBasicPBRec.fCopyPBHeader.fTotalTargetSize, &tempNumStr );
  382.             PrintLine( theCallBackPtr, kTotalSizeText, tempNumStr, "\p", "\p" );
  383.                             
  384.             // -- Installer Temp Dir ID
  385.             if( pExtenderPBPtr->fBasicPBRec.fCopyPBHeader.fInstallerTempDirID != -1 ) {
  386.                 tempFSSpec.name[0] = 0;
  387.                 tempFSSpec.parID = pExtenderPBPtr->fBasicPBRec.fCopyPBHeader.fInstallerTempDirID;
  388.                 tempFSSpec.vRefNum = pExtenderPBPtr->fBasicPBRec.fCopyPBHeader.fTargetFile.vRefNum;
  389.                 MakeFilePath( &(tempFSSpec), tempStr255 );
  390.                 PrintLine( theCallBackPtr, kInstallerTempDirIDText, tempStr255, "\p", "\p" );
  391.             }
  392.  
  393.             break;
  394.             
  395.         }
  396.  
  397. // -- ATOM TARGET SPECIFIC INFO ----------------------------------------------------------------------
  398.  
  399.     switch (pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fMessageID) {
  400.         case kInitialize :
  401.         case kSuccess :
  402.             break;
  403.         case kBeforePart :
  404.         case kAfterPart :
  405.             switch (pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fDataType) {
  406.                 case kFileAtomDataFork :
  407.                 case kFileAtomRsrcFork :
  408.                 case kFileAtomRsrcForkFromDataFork :
  409.                     break;
  410.                 case kRsrcAtom :
  411.                     // -- Resource Target Type
  412.                     BlockMove( &(pExtenderPBPtr->fRsrcCopyPBRec.fTargetRsrcType), &(tempStr255[2]), 4 );
  413.                     tempStr255[1] = '\'';
  414.                     tempStr255[6] = '\'';
  415.                     tempStr255[0] = 6;
  416.                     PrintLine( theCallBackPtr, kRsrcTargetRsrcTypeText, tempStr255, "\p", "\p" );
  417.                     
  418.                     // -- Resource Target ID
  419.                     NumToString( pExtenderPBPtr->fRsrcCopyPBRec.fTargetRsrcID, &tempNumStr );
  420.                     PrintLine( theCallBackPtr, kRsrcTargetRsrcIDText, tempNumStr, "\p", "\p" );
  421.  
  422.                     // -- Resource Target Name
  423.                     PrintLine( theCallBackPtr, kRsrcTargetRsrcNameText, pExtenderPBPtr->fRsrcCopyPBRec.fTargetRsrcName, "\p", "\p" );
  424.  
  425.                     // -- Resource Target Attributes
  426.                     NumToString( pExtenderPBPtr->fRsrcCopyPBRec.fTargetRsrcAttrs, &tempNumStr );
  427.                     PrintLine( theCallBackPtr, kRsrcTargetRsrcAttrsText, tempNumStr, "\p", "\p" );
  428.  
  429.                     break;
  430.                 case kFontAtom :
  431.                     // -- Font Target Type
  432.                     BlockMove( &(pExtenderPBPtr->fFontCopyPBRec.fTargetFontRsrcType), &(tempStr255[2]), 4 );
  433.                     tempStr255[1] = '\'';
  434.                     tempStr255[6] = '\'';
  435.                     tempStr255[0] = 6;
  436.                     PrintLine( theCallBackPtr, kFontTargetRsrcTypeText, tempStr255, "\p", "\p" );
  437.                     
  438.                     // -- Font Target ID
  439.                     if( pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fMessageID == kAfterPart ) {
  440.                         NumToString( pExtenderPBPtr->fFontCopyPBRec.fTargetFontRsrcID, &tempNumStr );
  441.                         PrintLine( theCallBackPtr, kFontTargetRsrcIDText, tempNumStr, "\p", "\p" );
  442.                     }
  443.                     
  444.                     // -- Font Target Name
  445.                     PrintLine( theCallBackPtr, kFontTargetRsrcNameText, pExtenderPBPtr->fFontCopyPBRec.fTargetFontRsrcName, "\p", "\p" );
  446.  
  447.                     // -- Font Target Attributes
  448.                     NumToString( pExtenderPBPtr->fFontCopyPBRec.fTargetFontRsrcAttrs, &tempNumStr );
  449.                     PrintLine( theCallBackPtr, kFontTargetRsrcAttrsText, tempNumStr, "\p", "\p" );
  450.                     
  451.                     break;
  452.                 default :
  453.                     break;
  454.                 }
  455.             break;
  456.         case kCancel :
  457.                 break;
  458.         }
  459.         
  460.         
  461.         
  462. // -- RESULT INFO ----------------------------------------------------------------------
  463.     switch (pResultCode) {
  464.         case kFatalError :            PrintLine( theCallBackPtr, kEndCallPart1, kErrorRtnMessageText, kEndCallPart3, "\p" );
  465.                                     break;
  466.         case kContinueAsNormal :    PrintLine( theCallBackPtr, kEndCallPart1, kOkRtnMessageText, kEndCallPart3, "\p" );
  467.                                     break;
  468.         case kCancelInstallation :    PrintLine( theCallBackPtr, kEndCallPart1, kCancelRtnMessageText, kEndCallPart3, "\p" );
  469.                                     break;
  470.         case kCopiedData :            PrintLine( theCallBackPtr, kEndCallPart1, kCopiedDataMessageText, kEndCallPart3, "\p" );
  471.                                     break;
  472.         }
  473.  
  474.  
  475. }
  476.  
  477.  
  478. #include  "AtomExtenderCBGlue.c"
  479. #include  "ActionHandlerCBGlue.c"